The Anatomy
of an AI Agent

with a focus on document agents

Open on your device

Scan to follow along on your phone or tablet

Agents are everywhere

• 2025 saw AI agents move from research curiosity to everyday tools
• Manus, Claude Code, Gemini, ChatGPT operator mode: each changed how we work
• 2026: agentic workflows are becoming the default, not the exception
• They browse the web, write code, process documents, manage tasks autonomously

What makes a good AI agent?

In this talk, we'll answer that question by going through the anatomy of one. We'll explore:

• How it thinks & acts — structured reasoning and tool use
• How it interacts with the world — filesystem, tools, chat interfaces
• How to control its flow — event-driven loops and step execution
• How to give it the right context — avoiding hallucinations, staying safe

The Brain: LLM as Foundation

• The LLM is the main actor: it produces thoughts, observations and actions
• Given the previous chat history, it reasons about what to do next
• Problem: LLMs are non-deterministic by nature
• Solution: structured outputs: JSON schemas that steer the model precisely

Steering the LLM:
Structured Outputs

Every LLM call in the agent uses structured generation: the model must respond in a predefined JSON schema, making outputs machine-readable and reliable.

• No free-form prose: every response has a typed, schema-validated structure
• Schemas are purpose-built per operation: think, act, observe, stop
• Forces clear separation of reasoning and action
• The agent wrapper exposes only structured generation methods

The Four Operations

These four operations, driven by structured outputs, are the base for the agent loop.

The Loop: Task Executor

The agent loop is a LlamaIndex Agent Workflow — an event-driven, stepwise execution engine that connects the LLM to the external world.

• A user prompt arrives as an input event, signalling the start of the workflow
• Each step dispatches a typed event to the next: think → act or stop → observe → think
• Tool results feed back as observations, restarting the think step
• The loop runs until the LLM produces a Stop (after at least one full cycle)

Event-Driven Execution

Windows on the World

The LLM loop is a generalist architecture. What defines a document processing agent are the interfaces through which it interacts with the external environment.

The Eyes: Virtual Filesystem

• Agent uses AgentFS: a virtualized filesystem, not the real machine one
• Full FS access for autonomous agents is dangerous, especially on shared machines
• Exposed operations: read, write, edit only, no delete or shell execution
• Scope is limited to the working directory and its children

The Limbs: Document Tools

Beyond plain-text file ops, the document agent uses LlamaParse tools that genuinely understand unstructured content (PDFs, Word docs, PowerPoint, Excel and more).

The Ears & Mouth: Chat Interface

• Users send .txt, .pdf, .docx documents via Telegram — the agent downloads them to AgentFS
• Text messages trigger agent tasks with full autonomous execution
• Key design choice: asynchronous (no loading spinners, push notifications when done)
• Perfectly matches LlamaIndex Workflows, which are async-first by design

A Note on Safety

• Virtual filesystem — no access to the real machine FS
• No shell execution — agent cannot run bash commands
• Read / write / edit only — no delete, no destructive operations
• No skill execution — behavior is extended via AGENTS.md, not runnable code

The Full Anatomy

Key Takeaways

• Structured outputs are what make LLM behaviour reliable inside an agent
• Event-driven loops turn a model into an autonomous, self-reflecting task executor
• Virtual filesystems enable safe, bounded document access without real-FS risk
• Async chat interfaces unlock long-running document workflows without blocking the user